Importing standard libraries¶
In [51]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
from sklearn.neighbors import KNeighborsClassifier
from scipy.stats import zscore
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.impute import SimpleImputer
from sklearn.metrics import confusion_matrix,accuracy_score
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
Reading data¶
In [2]:
cData=pd.read_csv('Data-Parkinsons.csv')
cData.head()
Out[2]:
Names of the variables and shape of the data set.¶
In [3]:
print(cData.columns)
Checking the presence of missing values.¶
In [4]:
cData.isnull().values.any()
Out[4]:
In [5]:
cData.info()
5 point summary¶
In [6]:
cData.describe()
Out[6]:
Get the target column distribution.¶
Target Variable is 'Status'. There is no need for 'name' column for further analysis since 'name' is just series alphanumeric variables
Univariate Analysis¶
In [17]:
sns.distplot(cData['MDVP:Fhi(Hz)'])
Out[17]:
In [22]:
sns.distplot(cData['MDVP:Jitter(%)'])
Out[22]:
In [23]:
sns.distplot(cData['MDVP:Jitter(Abs)'])
Out[23]:
In [24]:
sns.distplot(cData['MDVP:RAP'])
Out[24]:
In [25]:
sns.distplot(cData['MDVP:PPQ'])
Out[25]:
In [26]:
sns.distplot(cData['MDVP:Flo(Hz)'])
Out[26]:
In [27]:
sns.distplot(cData['Jitter:DDP'])
Out[27]:
In [28]:
sns.distplot(cData['MDVP:Shimmer'])
Out[28]:
In [29]:
sns.distplot(cData['Shimmer:APQ3'])
Out[29]:
In [30]:
sns.distplot(cData['Shimmer:APQ5'])
Out[30]:
In [31]:
sns.distplot(cData['MDVP:APQ'])
Out[31]:
In [32]:
sns.distplot(cData['Shimmer:DDA'])
Out[32]:
In [33]:
sns.distplot(cData['NHR'])
Out[33]:
In [34]:
sns.distplot(cData['HNR'])
Out[34]:
In [35]:
sns.countplot(cData['status'])
Out[35]:
In [36]:
sns.distplot(cData['RPDE'])
Out[36]:
In [37]:
sns.distplot(cData['DFA'])
Out[37]:
In [38]:
sns.distplot(cData['spread1'])
Out[38]:
In [39]:
sns.distplot(cData['spread2'])
Out[39]:
In [40]:
sns.distplot(cData['D2'])
Out[40]:
Understanding the relationship of the variables.¶
It is optimal that we can use heat map to find the correlations coefficient values. We will remove the less correlation coefficient columns. We can remove the irrelavant features it will minimize the accuracy of an algorithm. It will be better if we take relavent features columns then we can achive to get good accuracy..
In [42]:
# correlation coefficient values in each attributes.
correlation_values=cData.corr()['status']
correlation_values.abs().sort_values(ascending=False)
Out[42]:
In [46]:
corr_map=cData.corr()
sns.heatmap(corr_map,square=True,cmap="YlGnBu")
Out[46]:
In [45]:
# K value means how many features required to see in heat map
k=10
# finding the columns which related to output attribute and we are arranging from top coefficient correlation value to downwards.
cols=corr_map.nlargest(k,'status')['status'].index
# correlation coefficient values
coff_values=np.corrcoef(cData[cols].values.T)
sns.set(font_scale=1.25)
sns.heatmap(coff_values,cbar=True,annot=True,square=True,fmt='.2f',cmap="YlGnBu",
annot_kws={'size': 10},yticklabels=cols.values,xticklabels=cols.values)
plt.show()
Bivariate Analysis¶
In [47]:
#Distribution of columns.
sns.pairplot(cData[["name","MDVP:Fo(Hz)","MDVP:Fhi(Hz)","MDVP:Flo(Hz)","MDVP:Jitter(%)","MDVP:Jitter(Abs)","MDVP:RAP","MDVP:PPQ","Jitter:DDP","MDVP:Shimmer","MDVP:Shimmer(dB)","Shimmer:APQ3",
"Shimmer:APQ5","MDVP:APQ","Shimmer:DDA","NHR","HNR","status","RPDE","DFA","spread1","spread2","D2","PPE"]], diag_kind='kde')
Out[47]:
Dropping columns.¶
In [48]:
# Dropping columns which are highly correlated among each other.
cData.drop('name',axis=1,inplace=True)
cData.drop('Jitter:DDP',axis=1,inplace=True)
cData.drop('DFA',axis=1,inplace=True)
cData.drop('NHR',axis=1,inplace=True)
cData.drop('MDVP:Fhi(Hz)',axis=1,inplace=True)
Split the dataset into training and test set in the ratio of 70:30¶
In [49]:
from sklearn.model_selection import train_test_split
X = cData.drop('status',axis=1) # Predictor feature columns
Y = cData['status'] # Predicted class (1=True, 0=False)
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.3, random_state=1)
# 1 is just any random seed number
x_train.head()
Out[49]:
In [52]:
rep_0 = SimpleImputer(missing_values=0, strategy="mean")
cols=x_train.columns
x_train = pd.DataFrame(rep_0.fit_transform(x_train))
x_test = pd.DataFrame(rep_0.fit_transform(x_test))
x_train.columns = cols
x_test.columns = cols
x_train.head()
Out[52]:
1.Logistic Regression.¶
In [53]:
model = LogisticRegression(solver="liblinear")
model.fit(x_train, y_train)
y_predict = model.predict(x_test)
coef_df = pd.DataFrame(model.coef_)
coef_df['intercept'] = model.intercept_
print(coef_df)
Score of the Model.¶
In [54]:
model_score = model.score(x_test, y_test)
print(model_score)
Confusion Matrix of the model.¶
In [55]:
cm=metrics.confusion_matrix(y_test, y_predict, labels=[1, 0])
df_cm = pd.DataFrame(cm, index = [i for i in ["1","0"]],
columns = [i for i in ["Predict 1","Predict 0"]])
plt.figure(figsize = (7,5))
sns.heatmap(df_cm, annot=True)
Out[55]:
Classification Report¶
In [56]:
print("Classification Report")
print(metrics.classification_report(y_test,y_predict, labels=[1, 0]))
2.KNN Classifier¶
In [58]:
cData.groupby(["status"]).count()
Out[58]:
In [57]:
from scipy.stats import zscore
XScaled = X.apply(zscore) # convert all attributes to Z scale
XScaled.describe()
Out[57]:
In [59]:
X_train, X_test, Y_train, Y_test = train_test_split(XScaled, Y, test_size=0.30, random_state=42)
In [62]:
NNH = KNeighborsClassifier(n_neighbors= 5 , weights = 'distance' )
In [63]:
NNH.fit(X_train, Y_train)
Out[63]:
Score of the Model.¶
In [64]:
predicted_labels = NNH.predict(X_test)
NNH.score(X_test, Y_test)
Out[64]:
Confusion Matrix of the model.¶
In [66]:
cd=confusion_matrix(Y_test, predicted_labels)
print("confusion matirx of KNN classifier = \n",cd)
In [67]:
knnm=metrics.confusion_matrix(Y_test, predicted_labels)
knn_m = pd.DataFrame(knnm, index = [i for i in ["1","0"]],columns = [i for i in ["Predict 1","Predict 0"]])
plt.figure(figsize = (7,5))
sns.heatmap(knn_m, annot=True)
Out[67]:
Classification Report of the model.¶
In [68]:
print("Classification Report")
print(metrics.classification_report(Y_test, predicted_labels, labels=[1, 0]))
3.SVM classifier¶
In [69]:
x_train, x_test, y_train, y_test = train_test_split(X,Y, test_size = 0.3, random_state = 10)
In [70]:
svc_model = SVC(C= .1, kernel='linear', gamma= 1)
svc_model.fit(x_train, y_train)
prediction = svc_model .predict(x_test)
Score of the model.¶
In [71]:
print(svc_model.score(x_train, y_train))
print(svc_model.score(x_test, y_test))
Confusion Matrix for this model.¶
In [72]:
knnm=metrics.confusion_matrix(prediction,y_test)
knn_m = pd.DataFrame(knnm, index = [i for i in ["1","0"]],columns = [i for i in ["Predict 1","Predict 0"]])
plt.figure(figsize = (7,5))
sns.heatmap(knn_m, annot=True)
Out[72]:
Classification Report for this model.¶
In [73]:
print("Classification Report")
print(metrics.classification_report(prediction,y_test, labels=[1, 0]))
In [75]:
svc_model = SVC(kernel='rbf')
svc_model.fit(x_train, y_train)
Out[75]:
In [76]:
svc_model = SVC(kernel='poly')
svc_model.fit(x_train, y_train)
prediction = svc_model.predict(x_test)
print(svc_model.score(x_train, y_train))
print(svc_model.score(x_test, y_test))
In [77]:
svc_model = SVC(kernel='sigmoid')
svc_model.fit(x_train, y_train)
prediction = svc_model.predict(x_test)
print(svc_model.score(x_train, y_train))
print(svc_model.score(x_test, y_test))
4.Decision Tree¶
In [78]:
feature_cols = ['MDVP:Fo(Hz)',' MDVP:Flo(Hz)','MDVP:Jitter(%)','MDVP:Jitter(Abs)','MDVP:RAP','MDVP:PPQ','MDVP:Shimmer',
'MDVP:Shimmer(dB)','Shimmer:APQ3','Shimmer:APQ5','MDVP:APQ','Shimmer:DDA','HNR','RPDE','spread1','spread2','D2','PPE']
clf = DecisionTreeClassifier()
clf=clf.fit(x_train,y_train)
y_pred = clf.predict(x_test)
Accuracy Check for the model.¶
In [79]:
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
In [85]:
from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO
from IPython.display import Image
import pydotplus
import graphviz
dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,
filled=True, rounded=True,
special_characters=True,feature_names = feature_cols,class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_png('cd.png')
Image(graph.create_png())
Out[85]:
In [86]:
clf = DecisionTreeClassifier(criterion="entropy", max_depth=3)
clf = clf.fit(x_train,y_train)
y_pred = clf.predict(x_test)
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
In [87]:
from IPython.display import Image
from sklearn.tree import export_graphviz
import pydotplus
dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,
filled=True, rounded=True,
special_characters=True, feature_names = feature_cols,class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_png('cd1.png')
Image(graph.create_png())
Out[87]:
Train at least one standard Ensemble model - Random forest, Bagging,Boosting etc, and note the accuracy¶
1.Random Forest¶
In [88]:
from sklearn.ensemble import RandomForestClassifier
randf = RandomForestClassifier(n_estimators = 50)
randf = randf.fit(x_train, y_train)
In [89]:
predrandf= randf.predict(x_test)
accrandf = accuracy_score(y_test, predrandf)
print(accrandf)
2.AdaBoost¶
In [91]:
from sklearn.ensemble import AdaBoostClassifier
abc = AdaBoostClassifier(n_estimators=50,learning_rate=1)
model = abc.fit(x_train, y_train)
y_pred = model.predict(x_test)
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
3.Bagging Classifier¶
In [93]:
from sklearn.ensemble import BaggingClassifier
bag = BaggingClassifier(n_estimators=50, max_samples= .7, bootstrap=True, oob_score=True, random_state=22)
bag= bag.fit(x_train, y_train)
In [94]:
predBAG =bag.predict(x_test)
accBAG = accuracy_score(y_test, predBAG)
print(accBAG)
4.GradientBoost Classifier¶
In [95]:
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.ensemble import AdaBoostClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.ensemble import GradientBoostingClassifier
grad = GradientBoostingClassifier(n_estimators = 50, learning_rate = 0.1, random_state=22)
grad = grad.fit(x_train, y_train)
In [96]:
predgrad =grad.predict(x_test)
accgrad = accuracy_score(y_test, predgrad)
print(accgrad)
Train a meta-classifier and note the accuracy on test data¶
Stacking classifier¶
In [99]:
from sklearn import model_selection
from mlxtend.classifier import StackingClassifier
clf1 = KNeighborsClassifier(n_neighbors=1)
clf2 = RandomForestClassifier(random_state=1)
clf3 =SVC(C= .1, kernel='linear', gamma= 1)
lr = LogisticRegression()
sclf = StackingClassifier(classifiers=[clf1, clf2, clf3], meta_classifier=lr)
print('3-fold cross validation:\n')
for clf, label in zip([clf1, clf2, clf3, sclf],
['KNN',
'Random Forest',
'Naive Bayes',
'StackingClassifier']):
scores = model_selection.cross_val_score(clf, X, Y,
cv=3, scoring='accuracy')
print("Accuracy: %0.2f (+/- %0.2f) [%s]"
% (scores.mean(), scores.std(), label))
Compare all the models (minimum 5) and pick the best one among them.¶
In [114]:
# compare standalone models for binary classification
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from matplotlib import pyplot
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
return X, y
# get a list of models to evaluate
def get_models():
models = dict()
models['lr'] = LogisticRegression()
models['knn'] = KNeighborsClassifier()
models['cart'] = DecisionTreeClassifier()
models['svm'] = SVC()
models['bayes'] = GaussianNB()
return models
# evaluate a given model using cross-validation
def evaluate_model(model):
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
return scores
# define dataset
X, y = get_dataset()
# get the models to evaluate
models = get_models()
# evaluate the models and store results
results, names = list(), list()
for name, model in models.items():
scores = evaluate_model(model)
results.append(scores)
names.append(name)
print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
# plot model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.show()
In [119]:
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.ensemble import AdaBoostClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.ensemble import GradientBoostingClassifier
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
return X, y
# get a list of models to evaluate
def get_models():
models = dict()
models['ab'] = AdaBoostClassifier()
models['bc'] = KNeighborsClassifier()
models['gb'] = GradientBoostingClassifier()
return models
# define dataset
X, y = get_dataset()
# get the models to evaluate
models = get_models()
# evaluate the models and store results
results, names = list(), list()
for name, model in models.items():
scores = evaluate_model(model)
results.append(scores)
names.append(name)
print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
# plot model performance for comparison
pyplot.boxplot(results, labels=names, showmeans=True)
pyplot.show()
Conclusion¶
On performing several analysis on the given dataset, I conclude that the Gradient Boosting Classifier method is the most accurate for analysis with accuracy of 0.9491525423728814
In [ ]: